package com.kingyun.gpsinspection.purificationservice.services.activitiservice.ext.parser;

import com.kingyun.gpsinspection.purificationservice.services.activitiservice.ext.listener.CustomerExcutionListener;
import org.activiti.bpmn.constants.BpmnXMLConstants;
import org.activiti.bpmn.model.CancelEventDefinition;
import org.activiti.bpmn.model.EndEvent;
import org.activiti.bpmn.model.EventDefinition;
import org.activiti.bpmn.model.TerminateEventDefinition;
import org.activiti.engine.delegate.ExecutionListener;
import org.activiti.engine.impl.bpmn.parser.BpmnParse;
import org.activiti.engine.impl.bpmn.parser.handler.EndEventParseHandler;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.process.ScopeImpl;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 自定义流程结束解析器
 */
public class CustomerEndEventParseHandler extends EndEventParseHandler {

    private static final Logger logger = LoggerFactory.getLogger(CustomerEndEventParseHandler.class);
    @Override
    protected void executeParse(BpmnParse bpmnParse, EndEvent endEvent) {
        ActivityImpl endEventActivity = createActivityOnCurrentScope(bpmnParse, endEvent, BpmnXMLConstants.ELEMENT_EVENT_END);
        EventDefinition eventDefinition = null;
        if (!endEvent.getEventDefinitions().isEmpty()) {
            eventDefinition = endEvent.getEventDefinitions().get(0);
        }

        // Error end event
        if (eventDefinition instanceof org.activiti.bpmn.model.ErrorEventDefinition) {
            org.activiti.bpmn.model.ErrorEventDefinition errorDefinition = (org.activiti.bpmn.model.ErrorEventDefinition) eventDefinition;
            if (bpmnParse.getBpmnModel().containsErrorRef(errorDefinition.getErrorCode())) {
                String errorCode = bpmnParse.getBpmnModel().getErrors().get(errorDefinition.getErrorCode());
                if (StringUtils.isEmpty(errorCode)) {
                    logger.warn("errorCode is required for an error event " + endEvent.getId());
                }
                endEventActivity.setProperty("type", "errorEndEvent");
                errorDefinition.setErrorCode(errorCode);
            }
            endEventActivity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createErrorEndEventActivityBehavior(endEvent, errorDefinition));

            // Cancel end event
        } else if (eventDefinition instanceof CancelEventDefinition) {
            ScopeImpl scope = bpmnParse.getCurrentScope();
            if (scope.getProperty("type")==null || !scope.getProperty("type").equals("transaction")) {
                logger.warn("end event with cancelEventDefinition only supported inside transaction subprocess (id=" + endEvent.getId() + ")");
            } else {
                endEventActivity.setProperty("type", "cancelEndEvent");
                endEventActivity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createCancelEndEventActivityBehavior(endEvent));
            }

            // Terminate end event
        } else if (eventDefinition instanceof TerminateEventDefinition) {
            endEventActivity.setAsync(endEvent.isAsynchronous());
            endEventActivity.setExclusive(!endEvent.isNotExclusive());
            endEventActivity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createTerminateEndEventActivityBehavior(endEvent));

            // None end event
        } else if (eventDefinition == null) {
            endEventActivity.addExecutionListener(ExecutionListener.EVENTNAME_END,new CustomerExcutionListener());
            endEventActivity.setAsync(endEvent.isAsynchronous());
            endEventActivity.setExclusive(!endEvent.isNotExclusive());
            endEventActivity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createNoneEndEventActivityBehavior(endEvent));
        }
    }
}
